name	{lc_letter}({lc_letter}|_)*

lc_letter	[a-z]

identifier	({letter}|_)({letter}|{digit}|_)*

letter	{lowercase}|{uppercase}

lowercase	[a-z]

uppercase	[A-Z]

digit	[0-9]


stringliteral	{stringprefix}?({shortstring}|{longstring})

stringprefix	r|u|(ur)|R|U|(UR)|(Ur)|(uR)

shortstring	(\'{shortstringitem}*\')|(\"{shortstringitem}*\")

longstring	(\'\'\'{longstringitem}*\'\'\')|(\"\"\"{longstringitem}*\"\"\")

shortstringitem	{shortstringchar}|{escapeseq}

longstringitem	{longstringchar}|{escapeseq}


shortstringchar	[^\\\'\"\n](?# <any source character except \ or newline or the quote>)

longstringchar	[^\\](?# <any source character except \>)


escapeseq	\\(.|\n)(?# \ <any ASCII character>)

longinteger	{integer}(l|L)

integer	{decimalinteger}|{octinteger}|{hexinteger}


decimalinteger	{nonzerodigit}{digit}*|0

octinteger	0{octdigit}+

hexinteger	0(x|X){hexdigit}+


nonzerodigit	[1-9]

octdigit	[0-7]

hexdigit	{digit}|[a-f]|[A-F]


floatnumber	{pointfloat}|{exponentfloat}

pointfloat	{intpart}?{fraction}|{intpart}\.

exponentfloat	({intpart}|{pointfloat})exponent


intpart	{digit}+

fraction	\.{digit}+

exponent	(e|E)(+|-)?{digit}+

imagnumber	({floatnumber}|{intpart})(j|J)


atom	{identifier}|{literal}|{enclosure}

enclosure	{parenth_form}|{list_display}|{generator_expression}|{dict_display}|{string_conversion}


literal	{stringliteral}|{integer}|{longinteger}|{floatnumber}|{imagnumber}

parenth_form	\({expression_list}?\)

test	{or_test}|{lambda_form}

white_space	[ \t]

testlist	{test}({white_space}*,{white_space}*{test})*,?

list_display	\[{white_space}*{listmaker}?{white_space}*\]

listmaker	{expression}({list_for}|({white_space}*,{white_space}*{expression})*({white_space}*,)?)

list_iter	{list_for}|{list_if}

list_for	for{white_space}+{expression_list}{white_space}in{white_space}{testlist}{list_iter}?

list_if	if{white_space}+{test}{white_space}+{list_iter}?

generator_expression	"("{white_space}*{test}{white_space}+{genexpr_for}{white_space}*")"

genexpr_for	"for"{white_space}+{expression_list}{white_space}+"in"{test}{genexpr_iter}?

genexpr_iter	{genexpr_for}|{genexpr_if}

genexpr_if	"if"{white_space}+{test}{white_space}+{genexpr_iter}?

dict_display	\{{white_space}*{key_datum_list}?\}


key_datum_list	{key_datum}({white_space}*,{white_space}*{key_datum})*,?

key_datum	{expression}{white_space}*:{white_space}*{expression}

string_conversion	\`{expression_list}\`


primary	{atom}|{attributeref}|{subscription}|{slicing}|{call}

attributeref	{primary}\.{identifier}

subscription	{primary}\[{expression_list}\]


slicing	{simple_slicing}|{extended_slicing}

simple_slicing	{primary}{white_space}*\[{white_space}*{short_slice}\]

extended_slicing	{primary}{white_space}*\[{white_space}*{slice_list}\] 


slice_list ::= 
             slice_item ("," slice_item)* [","]
  
slice_item ::= 
             expression | proper_slice | ellipsis
  
proper_slice ::= 
             short_slice | long_slice

  
short_slice ::= 
             [lower_bound] ":" [upper_bound]
  
long_slice ::= 
             short_slice ":" [stride]
  
lower_bound ::= 
             expression
  
upper_bound ::= 

             expression
  
stride ::= 
             expression
  
ellipsis ::= 
             "..."

call ::= 
             primary "(" [argument_list [","]] ")"

             primary "(" [argument_list [","] |
	      test genexpr_for ] ")"                                                   
  
argument_list ::= 
             positional_arguments ["," keyword_arguments]

                                     ["," "*" expression]
                                     ["," "**" expression]
                | keyword_arguments ["," "*" expression]

                                    ["," "**" expression]
                | "*" expression ["," "**" expression]
                | "**" expression
  

positional_arguments ::= 
             expression ("," expression)*
  
keyword_arguments ::= 
             keyword_item ("," keyword_item)*
  
keyword_item ::= 
             identifier "=" expression


power ::= 
             primary ["**" u_expr]

u_expr ::= 
             power | "-" u_expr
              | "+" u_expr | "\~" u_expr

m_expr ::= 
             u_expr | m_expr "*" u_expr

              | m_expr "//" u_expr
              | m_expr "/" u_expr
                | m_expr "\%" u_expr
  
a_expr ::= 
             m_expr | a_expr "+" m_expr
              | a_expr "-" m_expr

<tex2html_comment_mark>41

shift_expr ::= 
             a_expr
              | shift_expr ( "<<" | ">>" ) a_expr

and_expr ::= 
             shift_expr | and_expr "\;SPMamp;" shift_expr

  
xor_expr ::= 
             and_expr | xor_expr "\textasciicircum" and_expr
  
or_expr ::= 
             xor_expr | or_expr "|" xor_expr

comparison ::= 
             or_expr ( comp_operator or_expr )*

  
comp_operator ::= 
             "<" | ">" | "==" | ">=" | "<=" | "<>" | "!="
                | "is" ["not"] | ["not"] "in"


expression ::= 
             or_test [if or_test else
              test] | lambda_form
  
or_test ::= 
             and_test | or_test "or" and_test
  
and_test ::= 
             not_test | and_test "and" not_test

  
not_test ::= 
             comparison | "not" not_test

lambda_form ::= 
             "lambda" [parameter_list]: expression

expression_list ::= 
             expression ( "," expression )* [","]


simple_stmt ::= expression_stmt
                | assert_stmt
                | assignment_stmt
                | augmented_assignment_stmt
                | pass_stmt
                | del_stmt
                | print_stmt

                | return_stmt
                | yield_stmt
                | raise_stmt
                | break_stmt
                | continue_stmt
                | import_stmt
                | global_stmt

                | exec_stmt

expression_stmt ::= 
             expression_list

assert_stmt ::= 
             "assert" expression ["," expression]

assignment_stmt ::= 
             (target_list "=")+ expression_list

  
target_list ::= 
             target ("," target)* [","]
  
target ::= 
             identifier
                | "(" target_list ")"
                | "[" target_list "]"

                | attributeref
                | subscription
                | slicing

augmented_assignment_stmt ::= 
             target augop expression_list
  
augop ::= 
             "+=" | "-=" | "*=" | "/=" | "\%=" | "**="

  <tex2html_comment_mark>47
              | ">>=" | "<<=" | "\&=" | "\textasciicircum=" | "|="

pass_stmt ::= 
             "pass"


del_stmt ::= 
             "del" target_list

print_stmt ::= 
             "print" ( \optionalexpression ("," expression)* \optional","
                | ">>" expression

                  \optional("," expression)+ \optional"," )

return_stmt ::= 
             "return" [expression_list]

yield_stmt ::= 
             "yield" expression_list


raise_stmt ::= 
             "raise" [expression ["," expression
              ["," expression]]]

break_stmt ::= 
             "break"

continue_stmt ::= 

             "continue"

import_stmt ::= 
             "import" module ["as" name]
                ( "," module ["as" name] )*
                | "from" module "import" identifier

                    ["as" name]
                  ( "," identifier ["as" name] )*
                | "from" module "import" "(" identifier
                    ["as" name]

                  ( "," identifier ["as" name] )* [","] ")"
                | "from" module "import" "*"
  
module ::= 
             (identifier ".")* identifier


global_stmt ::= 
             "global" identifier ("," identifier)*

exec_stmt ::= 
             "exec" expression
              ["in" expression ["," expression]]


compound_stmt ::= 
             if_stmt
                | while_stmt
                | for_stmt
                | try_stmt
                | with_stmt
                | funcdef
                | classdef

  
suite ::= 
             stmt_list NEWLINE
              | NEWLINE INDENT statement+ DEDENT
  
statement ::= 
             stmt_list NEWLINE | compound_stmt
  
stmt_list ::= 
             simple_stmt (";" simple_stmt)* [";"]


if_stmt ::= 
             "if" expression ":" suite
                ( "elif" expression ":" suite )*
                ["else" ":" suite]

while_stmt ::= 

             "while" expression ":" suite
                ["else" ":" suite]

for_stmt ::= 
             "for" target_list "in" expression_list
              ":" suite

                ["else" ":" suite]

try_stmt ::=  try1_stmt | try2_stmt
  
try1_stmt ::= 
             "try" ":" suite
                ("except" [expression

                             ["," target]] ":" suite)+
                ["else" ":" suite]
                ["finally" ":" suite]
  
try2_stmt ::= 

             "try" ":" suite
                "finally" ":" suite

with_stmt ::= 
  "with" expression ["as" target] ":" suite

funcdef	{decorators}? "def" funcname "(" [parameter_list] ")"
              ":" suite

decorators	{decorator}+

decorator	@{dotted_name}(\((argument_list ,?)?\))?\n

dotted_name	{identifier}(\.{identifier})*

parameter_list	({defparameter},)*((\*{identifier}(,\*\*{identifier})?)|(\*\*{identifier})|({defparameter},?))

defparameter	{parameter}(={expression})?

sublist	{parameter} (, {parameter})* ,?

parameter	{identifier}|(\({sublist}\))

funcname	{identifier}

classdef	class {classname} {inheritance}? : {suite}

inheritance	\({expression_list}?\)

classname	{identifier}

file_input	(\n|{statement})*

interactive_input	({stmt_list}?\n)|({compound_stmt}\n)

eval_input	{expression_list}(\n)*

input_input	{expression_list}\n 
